package org.convallaria.system.biz.service.sys.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.convallaria.system.biz.entity.SysMenu;
import org.convallaria.system.biz.mapper.SysMenuMapper;
import org.convallaria.system.biz.service.sys.SysMenuService;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Set;
import java.util.HashSet;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.convallaria.system.biz.entity.SysUserRole;
import org.convallaria.system.biz.entity.SysRoleMenu;
import org.convallaria.system.biz.mapper.SysUserRoleMapper;
import org.convallaria.system.biz.mapper.SysRoleMenuMapper;

/**
 * @Description <p>描述： </p>
 * @Author gjh
 * @Date 2025/9/27 11:17
 */
@Slf4j
@Service
public class SysMenuServiceImpl extends ServiceImpl<SysMenuMapper, SysMenu> implements SysMenuService {

    private final SysUserRoleMapper sysUserRoleMapper;
    private final SysRoleMenuMapper sysRoleMenuMapper;

    public SysMenuServiceImpl(SysUserRoleMapper sysUserRoleMapper, SysRoleMenuMapper sysRoleMenuMapper) {
        this.sysUserRoleMapper = sysUserRoleMapper;
        this.sysRoleMenuMapper = sysRoleMenuMapper;
    }
    /**
     * 分页查询菜单列表
     *
     * @param pageNum  页码
     * @param pageSize 页大小
     * @param menuName 菜单名称（可选）
     * @param menuType 菜单类型（可选）
     * @param status   状态（可选）
     * @param tenantId 租户ID（可选）
     * @return 菜单分页列表
     */
    @Override
    public IPage<SysMenu> pageMenus(Integer pageNum, Integer pageSize, String menuName, String menuType, String status, Long tenantId) {
        return null;
    }

    /**
     * 根据菜单ID获取菜单信息（带缓存）
     *
     * @param menuId 菜单ID
     * @return 菜单信息
     */
    @Override
    public SysMenu getMenuById(Long menuId) {
        return null;
    }

    /**
     * 获取菜单树结构
     *
     * @param tenantId 租户ID
     * @return 菜单树列表
     */
    @Override
    public List<SysMenu> getMenuTree(Long tenantId) {
        return null;
    }

    /**
     * 根据父菜单ID获取子菜单列表
     *
     * @param parentId 父菜单ID
     * @param tenantId 租户ID
     * @return 子菜单列表
     */
    @Override
    public List<SysMenu> getChildrenMenus(Long parentId, Long tenantId) {
        return null;
    }

    /**
     * 获取用户菜单树
     *
     * @param userId   用户ID
     * @param tenantId 租户ID
     * @return 用户菜单树
     */
    @Override
    public List<SysMenu> getUserMenuTree(Long userId, Long tenantId) {
        return null;
    }

    /**
     * 获取角色的菜单权限
     *
     * @param roleId   角色ID
     * @param tenantId 租户ID
     * @return 菜单权限列表
     */
    @Override
    public List<SysMenu> getRoleMenus(Long roleId, Long tenantId) {
        return null;
    }

    /**
     * 更新菜单信息（清除相关缓存）
     *
     * @param menu 菜单信息
     * @return 是否成功
     */
    @Override
    public boolean updateMenu(SysMenu menu) {
        return false;
    }

    /**
     * 删除菜单（清除相关缓存）
     *
     * @param menuId 菜单ID
     * @return 是否成功
     */
    @Override
    public boolean deleteMenu(Long menuId) {
        return false;
    }

    /**
     * 批量删除菜单（清除相关缓存）
     *
     * @param menuIds 菜单ID列表
     * @return 是否成功
     */
    @Override
    public boolean deleteMenus(List<Long> menuIds) {
        return false;
    }

    /**
     * 刷新菜单缓存
     *
     * @param menu 菜单信息
     * @return 菜单信息
     */
    @Override
    public SysMenu refreshMenuCache(SysMenu menu) {
        return null;
    }

    /**
     * 获取菜单的所有权限标识
     *
     * @param menuId 菜单ID
     * @return 权限标识集合
     */
    @Override
    public Set<String> getMenuPermissions(Long menuId) {
        return null;
    }

    /**
     * 获取用户的所有菜单权限
     *
     * @param userId   用户ID
     * @param tenantId 租户ID
     * @return 权限标识集合
     */
    @Override
    public Set<String> getUserMenuPermissions(Long userId, Long tenantId) {
        return null;
    }

    /**
     * 检查菜单名称是否唯一
     *
     * @param menuName 菜单名称
     * @param menuId   菜单ID（更新时排除自己）
     * @param parentId 父菜单ID
     * @param tenantId 租户ID
     * @return 是否唯一
     */
    @Override
    public boolean isMenuNameUnique(String menuName, Long menuId, Long parentId, Long tenantId) {
        return false;
    }

    /**
     * 检查菜单路径是否唯一
     *
     * @param path     菜单路径
     * @param menuId   菜单ID（更新时排除自己）
     * @param tenantId 租户ID
     * @return 是否唯一
     */
    @Override
    public boolean isMenuPathUnique(String path, Long menuId, Long tenantId) {
        return false;
    }

    /**
     * 检查菜单是否被角色使用
     *
     * @param menuId 菜单ID
     * @return 是否被使用
     */
    @Override
    public boolean isMenuInUse(Long menuId) {
        return false;
    }

    /**
     * 检查菜单是否有子菜单
     *
     * @param menuId 菜单ID
     * @return 是否有子菜单
     */
    @Override
    public boolean hasChildrenMenus(Long menuId) {
        return false;
    }

    /**
     * 构建菜单树结构
     *
     * @param menus 菜单列表
     * @return 菜单树列表
     */
    @Override
    public List<SysMenu> buildMenuTree(List<SysMenu> menus) {
        return null;
    }

    /**
     * 获取菜单的完整路径
     *
     * @param menuId 菜单ID
     * @return 菜单路径
     */
    @Override
    public String getMenuPath(Long menuId) {
        return null;
    }

    /**
     * 获取菜单的层级深度
     *
     * @param menuId 菜单ID
     * @return 层级深度
     */
    @Override
    public int getMenuDepth(Long menuId) {
        return 0;
    }

    /**
     * 根据权限标识获取菜单
     *
     * @param perms    权限标识
     * @param tenantId 租户ID
     * @return 菜单信息
     */
    @Override
    public SysMenu getMenuByPerms(String perms, Long tenantId) {
        return null;
    }

    /**
     * 获取所有按钮权限
     *
     * @param tenantId 租户ID
     * @return 按钮权限列表
     */
    @Override
    public List<SysMenu> getButtonPermissions(Long tenantId) {
        return null;
    }

    @Override
    public Set<String> getUserPermissions(Long userId) {
        log.info("获取用户权限: userId={}", userId);
        
        try {
            // 1. 查询用户角色关联
            LambdaQueryWrapper<SysUserRole> userRoleQuery = new LambdaQueryWrapper<>();
            userRoleQuery.eq(SysUserRole::getUserId, userId)
                        .eq(SysUserRole::getDelFlag, "0");
            
            List<SysUserRole> userRoles = sysUserRoleMapper.selectList(userRoleQuery);
            
            if (userRoles.isEmpty()) {
                return new HashSet<>();
            }
            
            // 2. 获取角色ID列表
            List<Long> roleIds = userRoles.stream()
                    .map(SysUserRole::getRoleId)
                    .collect(Collectors.toList());
            
            // 3. 查询角色菜单关联
            LambdaQueryWrapper<SysRoleMenu> roleMenuQuery = new LambdaQueryWrapper<>();
            roleMenuQuery.in(SysRoleMenu::getRoleId, roleIds)
                        .eq(SysRoleMenu::getDelFlag, "0");
            
            List<SysRoleMenu> roleMenus = sysRoleMenuMapper.selectList(roleMenuQuery);
            
            if (roleMenus.isEmpty()) {
                return new HashSet<>();
            }
            
            // 4. 获取菜单ID列表
            List<Long> menuIds = roleMenus.stream()
                    .map(SysRoleMenu::getMenuId)
                    .collect(Collectors.toList());
            
            // 5. 查询菜单权限
            LambdaQueryWrapper<SysMenu> menuQuery = new LambdaQueryWrapper<>();
            menuQuery.in(SysMenu::getMenuId, menuIds)
                    .eq(SysMenu::getStatus, "0")
                    .eq(SysMenu::getDelFlag, "0")
                    .isNotNull(SysMenu::getPerms)
                    .ne(SysMenu::getPerms, "");
            
            List<SysMenu> menus = list(menuQuery);
            
            // 6. 提取权限标识
            return menus.stream()
                    .map(SysMenu::getPerms)
                    .filter(perms -> perms != null && !perms.trim().isEmpty())
                    .collect(Collectors.toSet());
                    
        } catch (Exception e) {
            log.error("获取用户权限失败: userId={}", userId, e);
            return new HashSet<>();
        }
    }
}
